// package com.alibaba.druid.sql.ast.statement;

// import com.alibaba.druid.DbType;
// import com.alibaba.druid.sql.SQLUtils;
// import com.alibaba.druid.sql.ast.*;
// import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
// import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
// import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
// import com.alibaba.druid.sql.visitor.SQLASTVisitor;

// import java.sql.Types;
// import java.util.ArrayList;
// import java.util.List;
#pragma once

#include <string>
#include <list>

#include "../SQLExpr.h"
#include "../SQLExprImpl.h"
#include "../Object.h"
#include "../SQLObjectImpl.h"
#include "../SQLDataTypeImpl.h"
#include "../SQLReplaceable.h"
#include "../SQLObjectWithDataType.h"
#include "../SQLDbTypedObject.h"
#include "../AutoIncrementType.h"
#include "../SQLAnnIndex.h"
#include "../expr/SQLCharExpr.h"
#include "../expr/SQLIdentifierExpr.h"
#include "../expr/SQLPropertyExpr.h"

#include "../../../DbType.h"

#include "SQLAssignItem.h"
#include "SQLTableElement.h"
#include "SQLColumnConstraint.h"

class SQLName;
class SQLIdentifierExpr;
class SQLASTVisitor;
class Identity : virtual public SQLObjectImpl
{
public:
  int seed;
  int increment;

  BOOL_ptr notForReplication;
  BOOL_ptr cycle;

  int minValue;
  int maxValue;

  Identity();
  SHAREDOBJECT(Identity);
  int getSeed();

  void setSeed(int seed);

  int getIncrement();

  void setIncrement(int increment);

  BOOL_ptr isCycle();

  void setCycle(BOOL_ptr cycle);

  int getMinValue();

  void setMinValue(int minValue);

  int getMaxValue();

  void setMaxValue(int maxValue);

  BOOL_ptr isNotForReplication();

  void setNotForReplication(BOOL_ptr notForReplication);

  void accept0(SQLASTVisitor_ptr visitor) override;

  // Identity *clone();
  virtual SQLObject_ptr clone();
};

class SQLColumnDefinition
    : virtual public SQLObjectImpl,
      virtual public SQLTableElement,
      virtual public SQLObjectWithDataType,
      virtual public SQLReplaceable,
      virtual public SQLDbTypedObject
{
public:
  DbType_ptr dbType;

  SQLName_ptr name;
  SQLDataType_ptr dataType;
  SQLExpr_ptr defaultExpr;
  SQLColumnConstraint_list_ptr constraints;
  SQLExpr_ptr comment;

  BOOL_ptr enable;
  BOOL_ptr validate;
  BOOL_ptr rely;

  // for mysql
  BOOL_ptr autoIncrement;
  SQLExpr_ptr onUpdate;
  SQLExpr_ptr format;
  SQLExpr_ptr storage;
  SQLExpr_ptr charsetExpr;
  SQLExpr_ptr collateExpr;
  SQLExpr_ptr asExpr;
  BOOL_ptr stored;
  BOOL_ptr virtual_;
  BOOL_ptr visible;
  AutoIncrementType_ptr sequenceType;
  BOOL_ptr preSort; // for ads
  int preSortOrder; // for ads
  Identity_ptr identity;

  // for ads
  SQLExpr_ptr generatedAlawsAs;
  SQLExpr_ptr delimiter;          // for ads
  SQLExpr_ptr delimiterTokenizer; // for ads3.0 multivalue
  SQLExpr_ptr nlpTokenizer;       // for ads3.0 multivalue
  SQLExpr_ptr valueType;          // for ads3.0 multivalue
  BOOL_ptr disableIndex;          // for ads
  SQLExpr_ptr jsonIndexAttrsExpr; // for ads
  SQLAnnIndex_ptr annIndex;
  SQLExpr_ptr unitCount;
  SQLExpr_ptr unitIndex;
  SQLExpr_ptr step;
  SQLCharExpr_ptr encode;
  SQLCharExpr_ptr compression;
  SQLCharExpr_ptr aggType;      // for starrocks
  SQLCharExpr_ptr bitmap;       // for starrocks
  SQLCharExpr_ptr indexComment; // for starrocks

  // for aliyun data lake anlytics
  SQLAssignItem_list_ptr mappedBy;
  SQLAssignItem_list_ptr colProperties;

  SHAREDOBJECT(SQLColumnDefinition);
  SQLCharExpr_ptr getIndexComment();

  void setIndexComment(SQLCharExpr_ptr indexComment);

  SQLCharExpr_ptr getBitmap();

  void setBitmap(SQLCharExpr_ptr bitmap);

  SQLCharExpr_ptr getAggType();

  void setAggType(SQLCharExpr_ptr aggType);

  SQLColumnDefinition();

  Identity_ptr getIdentity();

  // for sqlserver
  void setIdentity(Identity_ptr identity);

  BOOL_ptr getEnable();

  void setEnable(BOOL_ptr enable);

  BOOL_ptr getValidate();

  void setValidate(BOOL_ptr validate);

  BOOL_ptr getRely();

  void setRely(BOOL_ptr rely);

  SQLName_ptr getName();

  string_ptr getColumnName();

  long nameHashCode64();

  string_ptr getNameAsString();

  void setName(SQLName_ptr name);

  void setName(string_ptr name);

  SQLDataType_ptr getDataType();

  int jdbcType();

  void setDataType(SQLDataType_ptr dataType);

  SQLExpr_ptr getDefaultExpr();

  void setDefaultExpr(SQLExpr_ptr defaultExpr);

  SQLColumnConstraint_list_ptr getConstraints();

  // BOOL_ptr isPrimaryKey() {
  //     for (SQLColumnConstraint constraint : constraints) {
  //         if (constraint instanceof SQLColumnPrimaryKey) {
  //             return BOOL::TRUE;
  //         }
  //     }

  //     if (parent instanceof SQLCreateTableStatement) {
  //         return ((SQLCreateTableStatement) parent)
  //                 .isPrimaryColumn(
  //                         nameHashCode64());
  //     }

  //     return BOOL::FALSE;
  // }

  // BOOL_ptr isOnlyPrimaryKey() {
  //     for (SQLColumnConstraint constraint : constraints) {
  //         if (constraint instanceof SQLColumnPrimaryKey) {
  //             return BOOL::TRUE;
  //         }
  //     }

  //     if (parent instanceof SQLCreateTableStatement) {
  //         return ((SQLCreateTableStatement) parent)
  //                 .isPrimaryColumn(
  //                         nameHashCode64());
  //     }

  //     return BOOL::FALSE;
  // }

  // BOOL_ptr isPartitionBy() {
  //     if (!(parent instanceof SQLCreateTableStatement)) {
  //         return BOOL::FALSE;
  //     }

  //     SQLCreateTableStatement* stmt = (SQLCreateTableStatement) parent;
  //     SQLPartitionBy partitioning = stmt.getPartitioning();
  //     if (partitioning == NULL) {
  //         return BOOL::FALSE;
  //     }

  //     if (name == NULL) {
  //         return BOOL::FALSE;
  //     }

  //     return partitioning.isPartitionByColumn(
  //             nameHashCode64());
  // }

  void addConstraint(std::shared_ptr<SQLColumnConstraint> constraint);

  void accept0(SQLASTVisitor_ptr visitor) override;

  SQLExpr_ptr getComment();

  void setComment(string_ptr comment);

  void setComment(SQLExpr_ptr comment);

  BOOL_ptr isVirtual();
  void setVirtual(BOOL_ptr virtual_);

  BOOL_ptr isStored();

  void setStored(BOOL_ptr stored);

  SQLExpr_ptr getCharsetExpr();

  void setCharsetExpr(SQLExpr_ptr charsetExpr);

  SQLExpr_ptr getCollateExpr();

  void setCollateExpr(SQLExpr_ptr x);

  SQLExpr_ptr getAsExpr();

  void setAsExpr(SQLExpr_ptr asExpr);

  BOOL_ptr isAutoIncrement();

  void setAutoIncrement(BOOL_ptr autoIncrement);

  SQLExpr_ptr getOnUpdate();

  void setOnUpdate(SQLExpr_ptr onUpdate);

  SQLExpr_ptr getFormat();

  void setFormat(SQLExpr_ptr format);

  SQLExpr_ptr getStorage();

  void setStorage(SQLExpr_ptr storage);

  BOOL_ptr replace(SQLExpr_ptr expr, SQLExpr_ptr target);

  void setUnitCount(SQLExpr_ptr unitCount);

  // string_ptr  computeAlias() {
  //     string_ptr  alias = NULL;

  //     if (name instanceof SQLIdentifierExpr) {
  //         alias = ((SQLIdentifierExpr) name).getName();
  //     } else if (name instanceof SQLPropertyExpr) {
  //         alias = ((SQLPropertyExpr) name).getName();
  //     }

  //     return SQLUtils.normalize(alias);
  // }

  virtual SQLObject_ptr clone();
  DbType_ptr getDbType();

  void setDbType(DbType_ptr dbType);

  void simplify();

  BOOL_ptr containsNotNullConstaint();

  SQLExpr_ptr getGeneratedAlawsAs();

  void setGeneratedAlawsAs(SQLExpr_ptr x);

  BOOL_ptr isVisible();

  void setVisible(BOOL_ptr visible);

  SQLExpr_ptr getDelimiter();

  BOOL_ptr isDisableIndex();

  void setDisableIndex(BOOL_ptr disableIndex);

  void setDelimiter(SQLExpr_ptr x);

  SQLExpr_ptr getDelimiterTokenizer();

  void setDelimiterTokenizer(SQLExpr_ptr delimiterTokenizer);

  SQLExpr_ptr getNlpTokenizer();

  void setNlpTokenizer(SQLExpr_ptr nlpTokenizer);

  SQLExpr_ptr getValueType();

  void setValueType(SQLExpr_ptr x);

  BOOL_ptr isPreSort();

  void setPreSort(BOOL_ptr preSort);

  int getPreSortOrder();

  void setPreSortOrder(int preSortOrder);

  SQLExpr_ptr getJsonIndexAttrsExpr();

  void setJsonIndexAttrsExpr(SQLExpr_ptr jsonIndexAttrsExpr);

  SQLAnnIndex_ptr getAnnIndex();

  void setAnnIndex(SQLAnnIndex_ptr x);

  AutoIncrementType_ptr getSequenceType();

  void setSequenceType(AutoIncrementType_ptr sequenceType);

  virtual string_ptr toString();

  SQLExpr_ptr getUnitCount();

  SQLExpr_ptr getUnitIndex();

  void setUnitIndex(SQLExpr_ptr unitIndex);

  SQLExpr_ptr getNplTokenizer();

  void setNplTokenizer(SQLExpr_ptr x);

  SQLExpr_ptr getStep();

  void setStep(SQLExpr_ptr step);

  SQLAssignItem_list_ptr getMappedBy();
  SQLAssignItem_list_ptr getMappedByDirect();
  SQLAssignItem_list_ptr getColProperties();

  SQLCharExpr_ptr getEncode();

  void setEncode(SQLCharExpr_ptr encode);

  SQLCharExpr_ptr getCompression();

  void setCompression(SQLCharExpr_ptr compression);

  SQLAssignItem_list_ptr getColPropertiesDirect();
};
